﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Bansud.SGR.CommonSGR;
using System.Text.RegularExpressions;
using System.IO;
using System.Web;
using System.Collections;

namespace condortravel.operaciones.common
{
    public class UploadFile: IDisposable 
    {
        private string m_NombreArchivo;
	private string m_RutaArchivo;
	private bool m_ValidarExtension = false;
	private bool m_ValidarPeso = false;
	private string m_DirDestino;
	private bool m_GenUniqueName;
	private string m_Carpeta = string.Empty;
	private bool m_ValidarExistencia = false;
	private string m_NombreOriginal;
	private string m_ExtensionArchivo;
	private double m_PesoArchivo;
	private long m_PesoMaximo = 1024 * 50 * 1024;
	//Private m_ExtensionesValidas As String = "^.+\.((gif)|(jpeg)|(jpg)|(zip)|(xls)|(doc)|(ppt)|(pdf)|(htm)|(html)|(txt)|(rar)|(mpp))$"

	private string m_ExtensionesValidas = "^.+\\.({0})$";
	public string Carpeta {
		get { return m_Carpeta; }
		set { m_Carpeta = value; }
	}
	public string ExtensionesValidas {
		get { return m_ExtensionesValidas; }
		set { m_ExtensionesValidas = value; }
	}

	public long PesoMaximo {
		get { return m_PesoMaximo; }
		set { m_PesoMaximo = value; }
	}

	public double PesoArchivo {
		get { return m_PesoArchivo / 1024; }
	}

	public string ExtensionArchivo {
		get { return m_ExtensionArchivo; }
	}

	public string NombreOriginal {
		get { return m_NombreOriginal; }
		set { m_NombreOriginal = value; }
	}

	public bool GenUniqueName {
		get { return m_GenUniqueName; }
		set { m_GenUniqueName = value; }
	}

	public bool ValidarExistencia {
		get { return m_ValidarExistencia; }
		set { m_ValidarExistencia = value; }
	}

	public bool ValidarPeso {
		get { return m_ValidarPeso; }
		set { m_ValidarPeso = value; }
	}

	public bool ValidarExtension {
		get { return m_ValidarExtension; }
		set { m_ValidarExtension = value; }
	}

	public string RutaArchivo {
		get { return m_RutaArchivo; }
		set { m_RutaArchivo = value; }
	}

	public string NombreArchivo {
		get { return m_NombreArchivo; }
		set { m_NombreArchivo = value; }
	}

	public string DirDestino {
		get { return m_DirDestino; }
		set { m_DirDestino = value; }
	}

	public bool ValidateExtension()
	{
		string checkFileregex = this.m_ExtensionesValidas;
		bool esValido = false;
		esValido = Regex.IsMatch(this.m_NombreArchivo, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
		return esValido;
	}

	public bool ValidateExtension(string nombreArchivo)
	{
		string checkFileregex = this.m_ExtensionesValidas;
		bool esValido = false;
		esValido = Regex.IsMatch(this.m_NombreArchivo, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
		return esValido;
	}

	public bool ValidateExtension(System.Web.UI.WebControls.FileUpload fileUp)
	{
		string checkFileregex = this.m_ExtensionesValidas;
		bool esValido = false;
		esValido = Regex.IsMatch(fileUp.PostedFile.FileName, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
		return esValido;
	}

	public bool ValidatePeso(System.Web.UI.WebControls.FileUpload fileUp)
	{
		bool esValido = false;
		try {
			HttpPostedFile uploadFile = fileUp.PostedFile;
			Int64 intArchivoPeso = uploadFile.ContentLength;

			esValido = (intArchivoPeso > this.m_PesoMaximo ? false : true);
		} catch (Exception ex) {
			esValido = false;
			throw new Exception("Error al validar Peso de Archivo : " + ex.Message);
		}
		return esValido;
	}


	public void CargarArchivo(System.Web.UI.WebControls.FileUpload fileUp)
	{
		if (this.m_ValidarExtension & !ValidateExtension(fileUp)) {
			//Throw New IOException("Extension no Valida")
			//Exit Sub
			throw new ExtensionNotValidException();
		}

		if (this.m_ValidarPeso & !ValidatePeso(fileUp)) {
			//Throw New IOException("Archivo muy Grande")
			//Exit Sub
			throw new BigFileException();
		}

		string UniqueName = (this.m_GenUniqueName ? System.Guid.NewGuid().ToString() : string.Empty);
		this.m_NombreOriginal = Path.GetFileName(fileUp.PostedFile.FileName);
		string NombreArchivoSave = string.Concat(UniqueName, this.m_NombreOriginal);



		if (!string.IsNullOrEmpty(this.m_Carpeta)) {
			string NuevoDirectory = this.m_DirDestino + this.m_Carpeta;
			if (!Directory.Exists(NuevoDirectory)) {
				Directory.CreateDirectory(NuevoDirectory);
			}
			this.m_DirDestino = NuevoDirectory + "\\";
		}
		string RutaCompleta = string.Concat(this.m_DirDestino, NombreArchivoSave);
		if (this.m_ValidarExistencia & ArchivoExiste(RutaCompleta)) {
			throw new FileExistException();
			//Throw New IOException("Archivo Existente")
			//Exit Sub
		}
		fileUp.PostedFile.SaveAs(RutaCompleta);
		this.m_ExtensionArchivo = Path.GetExtension(RutaCompleta);
		this.m_NombreArchivo = NombreArchivoSave;
		this.m_PesoArchivo = fileUp.PostedFile.ContentLength;
		this.m_RutaArchivo = RutaCompleta;

	}

	public bool ArchivoExiste(string RutaArchivo)
	{
		bool esValido = false;
		try {
			FileInfo NuevoArchivo = new FileInfo(RutaArchivo);

			esValido = NuevoArchivo.Exists;
		} catch (Exception ex) {
			esValido = false;
			throw new Exception("Error al verificar la existencia del Archivo : " + ex.Message);
		}
		return esValido;
	}

	public bool ArchivoExiste()
	{
		bool esValido = false;
		try {
			FileInfo NuevoArchivo = new FileInfo(this.RutaArchivo);
			esValido = NuevoArchivo.Exists;
		} catch (Exception ex) {
			esValido = false;
			throw new Exception("Error al verificar la existencia del Archivo : " + ex.Message);
		}
		return esValido;
	}

	public void Delete(string RutaArchivo)
	{
		if (ArchivoExiste(RutaArchivo)) {
			FileInfo _File = new FileInfo(RutaArchivo);
			_File.Delete();
		}

	}
	public void Move(string RutaOriginal, string RutaNueva)
	{
		//If Not String.IsNullOrEmpty(Me.m_Carpeta) Then
		string NuevoDirectory = this.m_DirDestino + this.m_Carpeta;
		if (!Directory.Exists(NuevoDirectory)) {
			Directory.CreateDirectory(NuevoDirectory);
		}
		//Me.m_DirDestino = NuevoDirectory & "\"
		//End If

		if (ArchivoExiste(RutaOriginal)) {
			System.IO.File.Move(RutaOriginal, RutaNueva);
		}
	}

	public UploadFile(bool ValidarExtension, bool ValidarPeso, bool ValidarExistencia)
	{
		this.ValidarPeso = ValidarPeso;
		this.ValidarExtension = ValidarExtension;
		this.ValidarExistencia = ValidarExistencia;
		this.config();
	}

	//Seguridad
	private string serverUser;
	private string serverPassword;
	private string domainName;
	private string serverName;

	private string folderName;

	private Impersonate objImpersonate = new Impersonate();
	private void config()
	{
		try {
			HttpContext ctx = HttpContext.Current;

			string registry = ctx.Application["RegistroClave"].ToString();
            //HD
            Hashtable table = null;

            //table = condortravel.operaciones.common.Util.readConnectioRegedit((String)ctx.Application[AppStatic.CONNECTION_REGEDIT_FILESERVER]);
            if (table != null)
            {
                this.serverName = table["ServerName"].ToString();
                this.serverUser = table["ServerUser"].ToString();
                this.serverPassword = table["ServerPassword"].ToString();
                this.domainName = table["DomainName"].ToString();
                this.folderName = table["FolderName"].ToString();


                //HD
                //string connectionString = SGRUtil.obtenerCadenaConexion(eCadenaConexion.Upload, false);
                //LeeRegistro(registry, "CadenaConexionUpload")
                //HD 20070305
                string strarg = null;
                //HD 20070305
                //Hashtable configTable = SGRUtil.leerCadenaConexion(connectionString);

                //HD 20070305

                strarg = System.Configuration.ConfigurationSettings.AppSettings["ExtensionUpload"];

                m_ExtensionesValidas = string.Format(m_ExtensionesValidas, strarg);
            }
		//HD 20070305
		} catch (Exception ex) {
			throw new Exception(ex.Message, ex);
		}

	}


	public bool obtenerPermisos()
	{
		bool retornar = false;
		try {
			retornar = objImpersonate.impersonateValidUser(this.serverUser, this.domainName, this.serverPassword);
		} catch (Exception ex) {
			throw new Exception(ex.Message);
		}

		return retornar;
	}

	public void dejarPermisos()
	{
		try {
			this.objImpersonate.undoImpersonation();
		} catch (Exception ex) {
			throw new Exception(ex.Message);
		}
	}

	public string Folder {
		get { return string.Concat("\\\\", this.serverName, "\\", this.folderName, "\\"); }
	}

	public void CrearCarpeta(string carpeta)
	{
		string ruta = string.Concat(this.Folder, carpeta);
		try {
			if (!Directory.Exists(ruta)) {
				Directory.CreateDirectory(ruta);
			}
		} catch (Exception ex) {
			throw new Exception(ex.Message, ex);
		}
	}

    #region Implementation of IDisposable

    ~UploadFile()
    {
        Dispose(false);
    }

    /// <summary>
    /// Performs application-defined tasks associated with freeing,
    /// releasing, or resetting unmanaged resources.
    /// </summary>
    /// <filterpriority>2</filterpriority>
    public void Dispose()
    {
        Dispose(false);
    }

    private void Dispose(bool disposing)
    {      
        if (disposing) GC.SuppressFinalize(this);
    }

    #endregion
    }
    
}
